package cn.study.forkjointest.recursiveaction;

import cn.study.forkjointest.util.Utils;

import java.util.Arrays;

/**
 * @Author     ：跟大佳一起学架构
 * @Description： JDK常用sort的区别
 */
public class JdkArrayTest {
    public static void main(String[] args){

        int[] arrayToSortByMergeSort1 = Utils.buildRandomIntArray(20_000_000);
        int[] arrayToSortByMergeSort2 = Utils.buildRandomIntArray(20_000_000);

        Integer[] arrayToSortByMergeSort3 = Arrays.stream(arrayToSortByMergeSort2)
            .boxed() // 直接装箱转换为Stream<Integer>
            .toArray(Integer[]::new); // 收集到Integer[]

        long startTime = System.nanoTime();

        //  一、数组排序对比
        // 1、sort 用到了快速排序
        Arrays.sort(arrayToSortByMergeSort1);
        System.out.println("Arrays quickSort:"+(System.nanoTime()-startTime)/(1000f*1000f));

        // 2、 归并排序-对象类型
        startTime = System.nanoTime();
        Arrays.sort(arrayToSortByMergeSort3);
        System.out.println("Arrays 归并 Sort:"+(System.nanoTime()-startTime)/(1000f*1000f));

        // 3、parallelSort 用到了forkJoin 并行归并排序
        startTime = System.nanoTime();
        Arrays.parallelSort(arrayToSortByMergeSort2);
        System.out.println("Arrays parallelMergeSort:"+(System.nanoTime()-startTime)/(1000f*1000f));

    }



    // 主方法调用归并排序
    public static void mergeSort(int[] array) {
        if (array.length < 2) {
            return; // 基本情况，数组只有一个元素或为空时不需要排序
        }
        int mid = array.length / 2;
        int[] left = new int[mid];
        int[] right = new int[array.length - mid];

        // 分割数组到两个子数组
        for (int i = 0; i < mid; i++) {
            left[i] = array[i];
        }
        for (int i = mid; i < array.length; i++) {
            right[i - mid] = array[i];
        }

        // 递归对两个子数组进行归并排序
        mergeSort(left);
        mergeSort(right);

        // 合并排序后的子数组
        merge(array, left, right);
    }

    // 合并两个已排序的子数组
    private static void merge(int[] array, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                array[k++] = left[i++];
            } else {
                array[k++] = right[j++];
            }
        }
        // 将剩余元素复制到原数组
        while (i < left.length) {
            array[k++] = left[i++];
        }
        while (j < right.length) {
            array[k++] = right[j++];
        }
    }
}